package com.ea.admin.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ea.admin.mapper.AdminAccountMapper;
import com.ea.admin.mapper.DeptInfoMapper;
import com.ea.admin.pojo.Enum.RoleCode;
import com.ea.admin.pojo.po.AdminAccount;
import com.ea.admin.pojo.po.DeptInfo;
import com.ea.admin.pojo.vo.account.ContactAdminVo;
import com.ea.admin.pojo.vo.department.DepartmentVo;
import com.ea.admin.service.*;
import com.ea.common.result.BizException;
import com.ea.common.result.ErrorCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class DeptServiceImpl implements DepartmentService {
    @Resource
    DeptInfoMapper deptInfoMapper;
    @Resource
    AdminAccountMapper adminAccountMapper;
    @Resource
    AccountService accountService;
    @Resource
    CompanyPermissionService companyPermissionService;
    @Resource
    DeptPermissionService deptPermissionService;
    @Resource
    ConfigService configService;
    @Resource
    CheckAccountService checkAccountService;

    @Override
    public List<DepartmentVo> getDepartmentList(List<Long> companyIdList, Long accountId) {
        // 获得所有单位权限，检查是否有该单位的权限
        List<Long> allCompanyIdList = companyPermissionService.getCompanyIdList(accountId);
        if (companyIdList == null || companyIdList.isEmpty()) {
            companyIdList = allCompanyIdList;
        } else if (!new HashSet<>(allCompanyIdList).containsAll(companyIdList)) {
            throw new BizException(ErrorCode.USER_COMPANY_PERMISSION_ERROR);
        } else {
            // 有参数，且权限满足，去重
            companyIdList = new ArrayList<>(new HashSet<>(companyIdList));
        }

        List<DepartmentVo> deptPermission = deptPermissionService.getDeptPermission(companyIdList, accountId);
        log.info("deptPermission:{}", deptPermission);
        return deptPermission;
    }

    @Override
    public Long addDepartment(String deptName, Long supDeptId, Long companyId, Long accountId, Long deptContactAccountId, String deptContactName, String deptContactPhoneNum, String deptContactUsername, String deptContactPassword, String deptContactRePassword) {
        Long adminRoleId = adminAccountMapper.selectById(accountId).getAdminRoleId();
        companyPermissionService.checkCompanyPermission(accountId, companyId);

        // 检查部门名称是否重复
        LambdaQueryWrapper<DeptInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DeptInfo::getDeptName, deptName);
        wrapper.eq(DeptInfo::getCompanyId, companyId);
        if (deptInfoMapper.selectCount(wrapper) > 0) {
            throw new BizException(ErrorCode.SYSTEM_RESOURCE_EXISTS_DEPT_NAME_ERROR);
        }
        // 检查进行操作的部门层级管理员是否有足够的权限
        if(adminRoleId== RoleCode.DEPT_SUPER_ADMIN.getCode().longValue()||
                adminRoleId== RoleCode.DEPT_ADMIN.getCode().longValue()) {
            deptPermissionService.checkDeptPermission(accountId, supDeptId);
        }

        DeptInfo deptInfo = new DeptInfo();
        DeptInfo supDeptInfo = null;
        deptInfo.setDeptName(deptName);
        deptInfo.setSupDeptId(supDeptId);
        deptInfo.setCompanyId(companyId);

        AdminAccount adminAccount;
        // 如果 参数中有id，且其余都为空，则选择现有联系人
        if (deptContactAccountId != null
                        && (deptContactUsername == null || deptContactUsername.isEmpty())
                        && (deptContactName == null || deptContactName.isEmpty())
                        && (deptContactPassword == null || deptContactPassword.isEmpty())
                        && (deptContactRePassword == null || deptContactRePassword.isEmpty())
                        && (deptContactPhoneNum == null || deptContactPhoneNum.isEmpty())
        ) {
            log.info("addAdmin  部门默认超级管理员");
            // 检查是否是可选的联系人
            adminAccount = checkAccountService.checkAdminAccount(deptContactAccountId);
            // 检查部门联系人是否有足够的权限 —— 或许直接给他添加权限就行了
            // deptPermissionService.checkCompanyPermissionError(supCompanyId, deptContactAccountId);
            // 是否是部门超管
            if (!adminAccount.getAdminRoleId().equals(RoleCode.DEPT_SUPER_ADMIN.getCode().longValue())) {
                throw new BizException(ErrorCode.USER_PARAM_ERROR_NOT_DEPT_SUPER_ADMIN);
            }
            deptInfo.setContactAdminId(adminAccount.getAccountId());
        }
        // 如果 参数中有 创建用户相关的参数
        else if (
                (deptContactAccountId == null || deptContactAccountId.equals(0L))
                        && deptContactUsername != null && !deptContactUsername.isEmpty()
                        && deptContactName != null && !deptContactName.isEmpty()
                        && deptContactPassword != null && !deptContactPassword.isEmpty()
                        && deptContactRePassword != null && !deptContactRePassword.isEmpty()
                        && deptContactPhoneNum != null && !deptContactPhoneNum.isEmpty()) {
            // 添加部门联系人 - 部门默认超级管理员
            adminAccount = accountService.addAdmin(
                    deptContactUsername,
                    deptContactPassword,
                    deptContactRePassword,
                    deptContactName,
                    deptContactPhoneNum,
                    RoleCode.DEPT_SUPER_ADMIN.getCode().longValue());
            deptInfo.setContactAdminId(adminAccount.getAccountId());
        } else {
            // 将contactAdminId 设置成null
            adminAccount = null;
            deptInfo.setContactAdminId(null);
        }

        // 如果没有上级部门，则层级为0
        if (supDeptId == null) {
            deptInfo.setLevel(0);
        } else {
            //否则，先获取父级部门的层级，然后加1
            supDeptInfo = deptInfoMapper.selectById(supDeptId);
            if (supDeptInfo == null) {
                throw new BizException(ErrorCode.SYSTEM_RESOURCE_DEPT_NOT_EXISTS);
            }
            // 检查上级部门是否属于本公司
            if (!supDeptInfo.getCompanyId().equals(companyId)) {
                throw new BizException(ErrorCode.USER_PARAM_ERROR_DEPT_NOT_BELONG_COMPANY);
            }

            deptInfo.setLevel(supDeptInfo.getLevel() + 1);
        }

        deptInfoMapper.insert(deptInfo);


        if (adminAccount != null) {
            // 为默认管理员添加该单位的单位权限
            companyPermissionService.addCompanyPermission(adminAccount.getAccountId(), deptInfo.getCompanyId());
            // 为默认管理员添加该单位的单位权限
            deptPermissionService.addDeptPermission(adminAccount.getAccountId(), deptInfo.getDeptId());
        }
        // 为超级管理员和上级单位的管理员添加该部门的权限
        log.info("为超级管理员和上级单位的管理员添加该部门的权限");
        addDeptPermissionToSuperAdmin(deptInfo.getDeptId(), supDeptInfo, companyId);

        return deptInfo.getDeptId();
    }

    public void addDeptPermissionToSuperAdmin(Long deptId, DeptInfo supDeptId, Long companyId) {
        // 查出管理员的id
        Set<Long> adminIdSet = new HashSet<>(accountService.getSuperAdminIdList());
        // 如果有上级部门，则需要给上级部门的管理员也 添加该部门的管理权限
        if (supDeptId != null) {
            adminIdSet.addAll(deptPermissionService.getAdminId(supDeptId.getDeptId()));
        }
        // 给 部门所属的单位的单位管理员 添加部门权限
        adminIdSet.addAll(companyPermissionService.getAdminId(companyId));
        log.info("adminIdSet:{}", adminIdSet);
        List<Long> list = adminIdSet.stream().filter(Objects::nonNull).collect(Collectors.toList());
        log.info("list:{}", list);
        // 给超级管理员和上级管理员添加 该部门的管理权限
        if (!list.isEmpty()) {
            deptPermissionService.addDeptPermission(list, deptId);
        }
    }

    @Override
    public void editDepartment(Long deptId, String deptName, Long supDeptId, Long deptContactId, Long accountId) {
        // 检查部门是否存在
        DeptInfo deptInfo = deptInfoMapper.selectById(deptId);
        if (deptInfo == null) {
            throw new BizException(ErrorCode.SYSTEM_RESOURCE_DEPT_NOT_EXISTS);
        }

        // 检查是否拥有修改前单位的 单位管理权限
        Long adminRoleId = adminAccountMapper.selectById(accountId).getAdminRoleId();
        companyPermissionService.checkCompanyPermission(accountId, deptInfo.getCompanyId());

        // 检查是否有此部门的权限
        if(adminRoleId== RoleCode.DEPT_SUPER_ADMIN.getCode().longValue()||
                adminRoleId== RoleCode.DEPT_ADMIN.getCode().longValue()){
        deptPermissionService.checkAccountDept(accountId, deptId);
        }

        // 如果参数中的 Dept 联系人不为空
        if (deptContactId != null) {
            // 检查Dept的联系人是否修改
            if ((Objects.equals(deptContactId, deptInfo.getContactAdminId()))) {
                // 如果修改，首先判断修改后的联系人是否存在
                AdminAccount adminAccount = checkAccountService.checkAdminAccount(deptContactId);

                // 判断新联系人是否具有本部门的管理权限
                deptPermissionService.checkAccountDept(deptContactId, deptId);

                // 判断联系人是否是部门超管
                if (!adminAccount.getAdminRoleId().equals(RoleCode.DEPT_SUPER_ADMIN.getCode().longValue())) {
                    throw new BizException(ErrorCode.USER_PARAM_ERROR_NOT_DEPT_SUPER_ADMIN);
                }

                deptInfo.setContactAdminId(adminAccount.getAccountId());
            }
        }

        if (!deptName.equals(deptInfo.getDeptName())) {
            // 检查部门名称是否存在
            LambdaQueryWrapper<DeptInfo> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(DeptInfo::getDeptName, deptName);
            wrapper.eq(DeptInfo::getCompanyId, deptInfo.getCompanyId());
            if (deptInfoMapper.selectCount(wrapper) > 0) {
                throw new BizException(ErrorCode.SYSTEM_RESOURCE_EXISTS_DEPT_NAME_ERROR);
            }
            deptInfo.setDeptName(deptName);
        }
        if (supDeptId == null || !supDeptId.equals(deptInfo.getSupDeptId())) {
            DeptInfo supDeptInfo;
            // 如果没有上级部门，则层级为0
            if (supDeptId == null) {
                // 检查当前用户是否有为 单位超管、单位管理、部门管理
                AdminAccount nowAccount = adminAccountMapper.selectById(accountId);
                if (nowAccount == null) {
                    throw new BizException(ErrorCode.SYSTEM_RESOURCE_ADMIN_ACCOUNT_NOT_EXISTS);
                }
                if (!nowAccount.getAdminRoleId().equals(RoleCode.SUPER_ADMIN.getCode().longValue())
                        && !nowAccount.getAdminRoleId().equals(RoleCode.COMPANY_SUPER_ADMIN.getCode().longValue())
                        && !nowAccount.getAdminRoleId().equals(RoleCode.COMPANY_ADMIN.getCode().longValue())
                        && !nowAccount.getAdminRoleId().equals(RoleCode.DEPT_SUPER_ADMIN.getCode().longValue())) {
                    throw new BizException(ErrorCode.USER_PERMISSION_ERROR_ONLY_COMPANY_SUPER_AMIN_COMPANY_ADMIN_DEPT_SUPER_ADMIN);
                }

                deptInfo.setLevel(0);

                // 设置 sup dept id 为空
                deptInfoMapper.removeSupDeptId(deptId);
            } else {
                if (supDeptId.equals(deptInfo.getDeptId())) {
                    // 上级 dept 的 id 不能等于 自身 的 id
                    throw new BizException(ErrorCode.USER_PARAM_ERROR_SUP_DEPT_ERROR);
                }

                //否则，先获取父级部门的层级，然后加1
                supDeptInfo = deptInfoMapper.selectById(supDeptId);

                if (supDeptInfo == null) {
                    throw new BizException(ErrorCode.SYSTEM_RESOURCE_DEPT_NOT_EXISTS);
                }
                // 检查上级部门是否属于本公司
                if (!supDeptInfo.getCompanyId().equals(deptInfo.getCompanyId())) {
                    throw new BizException(ErrorCode.USER_PARAM_ERROR_DEPT_NOT_BELONG_COMPANY);
                }

                deptInfo.setLevel(supDeptInfo.getLevel() + 1);
            }
            deptInfo.setSupDeptId(supDeptId);
        }

        deptInfoMapper.updateById(deptInfo);
    }

    @Override
    public void deleteDepartment(Long deptId, Long accountId) {
        // 检查部门是否存在
        DeptInfo deptInfo = deptInfoMapper.selectById(deptId);
        if (deptInfo == null) {
            throw new BizException(ErrorCode.SYSTEM_RESOURCE_DEPT_NOT_EXISTS);
        }
        // 检查是否拥有此单位的 单位管理权限
        companyPermissionService.checkCompanyPermission(accountId, deptInfo.getCompanyId());

        // 是否有此部门的权限
        deptPermissionService.checkAccountDept(accountId, deptId);

        // 获取所有下级部门id
        List<Long> query = new ArrayList<>();
        query.add(deptId);
        List<Long> allDeptIdList = deptInfoMapper.getAllSubDeptIdByDeptId(query);
        // 检查部门及其下级部门是否有用户信息
        if (deptInfoMapper.checkIfDeptHasUser(allDeptIdList)) {
            throw new BizException(ErrorCode.SYSTEM_RESOURCE_EXISTS_DEPT_HAS_USER_ERROR);
        }

        // 检查部门及其下级部门是否有管理员信息
        //if (deptInfoMapper.checkIfDeptHasAdmin(allDeptIdList)) {
        //    throw new BizException(ErrorCode.SYSTEM_RESOURCE_EXISTS_DEPT_HAS_ADMIN_ERROR);
        //}
        deptInfoMapper.deleteRelatedDeptByDeptId(deptId);
    }

    @Override
    public List<ContactAdminVo> searchContact(Long accountId, Long companyId, String contactName) {
        // 检查当前管理员是否有此单位的权限
        companyPermissionService.checkCompanyPermission(accountId, companyId);

        return deptPermissionService.getAllAdminInfoByCompanyIdAndName(companyId, contactName);
    }

    @Override
    public Integer getTotalCount(List<Long> queryDeptIdList) {
        return deptInfoMapper.getTotalCount(queryDeptIdList);
    }
}
